package com.kamistoat.meimeistore.seckill.web;

import com.kamistoat.common.To.SecKillTo.SecKillProductCacheTo;
import com.kamistoat.common.utils.R;
import com.kamistoat.meimeistore.seckill.feign.CouponFeignService;
import com.kamistoat.meimeistore.seckill.service.SecKillService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Controller
public class SecKillController {

    @Autowired
    SecKillService secKillService;
    @Autowired
    CouponFeignService couponFeignService;

    /**
     * 返回当前时间段的秒杀活动
     * 如果当前时间段没有秒杀则返回下一场秒杀
     *
     * @return
     */
    @GetMapping("/getcurrentseckillsession")
    @ResponseBody
    public List<SecKillProductCacheTo> getCurrentSecKillSession() {
        return secKillService.getCurrentSecKillSession();
    }

    /**
     * 获取未来所有的秒杀场次的商品信息
     * 外层List的每一个元素是一场秒杀
     * 每层List的每一个元素是这场秒杀的商品信息
     *
     * @return
     */
    @GetMapping("/getfutureseckillsession")
    @ResponseBody
    public List<List<SecKillProductCacheTo>> getFutureSecKillSessionList() {
        return secKillService.getFutureSecKillSessionList();
    }

    ;

    /**
     * 商品详情页，远程查询该商品未来三天是否存在秒杀服务
     *
     * @param skuId skuId
     * @return 类间传输To
     */
    @ResponseBody
    @GetMapping("/getskuseckillinfo")
    public SecKillProductCacheTo getSkuSecKill(@RequestParam Long skuId) {
        return secKillService.getSkuSecKill(skuId);
    }


    /**
     * 商品详情页参与商品秒杀
     *
     * @param sessionProId 场次-商品关联id。全局唯一
     * @param randomCode   秒杀商品随机码
     * @param skuId        商品skuId，用于和场次-商品关联Id做联合检查
     * @param num          要购买多少件商品
     * @return 是否成功
     */
    @ResponseBody
    @GetMapping("/seckillPro")
    public R secKillPro(@RequestParam Long sessionProId,
                        @RequestParam String randomCode,
                        @RequestParam Long skuId,
                        @RequestParam Integer num) {
        return secKillService.secKillPro(sessionProId, randomCode, skuId, num);
    }

    /**
     * 第二种实现.此时没到扣信号量的阶段，只是验证信号量。如果通过则进入确认订单阶段，如果不通过则拦截。
     * 此处是唯一直面全部流量的地方，通过信号量机制，限制大部分流量，保证后序只有少量流量通过
     * 暂时人为限定该接口只能通过商品详情页点击进来，而不是购物车
     */
    @GetMapping("/seckillProSec")
    public String secKillProSec(@RequestParam Long sessionProId,
                                @RequestParam String randomCode,
                                @RequestParam Long skuId,
                                @RequestParam Integer num,
                                Model model) {
        R status = secKillService.secKillProSec(sessionProId, randomCode, skuId, num);
        if ((int) status.get("code") == 0) {
            String redirect = "redirect:http://order.meimeistore.com/seckillToTrade?" +
                    "sessionIdProId=" + sessionProId.toString() +
                    "&randomCode=" + randomCode +
                    "&skuId=" + skuId.toString() +
                    "&num=" + num.toString();
            return redirect;
        } else {
            // 已无信号量，直接返回
            model.addAttribute("seckillCheckMsg", status.get("msg"));
            return "redirect:http://meimeistore.com/" + skuId.toString() + ".html";
        }
    }

    /**
     * 删除redis中已经缓存的原秒杀
     * 并重新检查相同id是否是3天以内的秒杀，如果是，立刻上架
     */
    @ResponseBody
    @RequestMapping("meimeistoreseckill/delete")
    public R delete_ReUp_RedisSessions(@RequestParam List<String> redisSessionKeyList) {
        secKillService.delete_ReUp_RedisSessions(redisSessionKeyList);
        return R.ok();
    }

}
